{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "2a7aff79",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "from tensorflow.keras.models import load_model\n",
    "from tensorflow.keras import Model\n",
    "from tensorflow.keras.layers import Dense, Dropout, GlobalAveragePooling1D\n",
    "import numpy as np\n",
    "\n",
    "# Load the pretrained 23-class model\n",
    "base_model = load_model('C:\\\\Users\\\\mstew\\\\OneDrive\\\\Curtin Univeristy\\\\COMP6011\\\\Task 3\\\\ECG-classification-main\\\\Trained models\\\\Twenty-three-classification\\\\12 leads.h5')  # Replace with actual path\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "e4452a37",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# Freeze all layers\n",
    "for layer in base_model.layers:\n",
    "    layer.trainable = False\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "d095393d",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# Replace the head with a new 7-class output layer\n",
    "x = base_model.layers[-2].output if 'dense' in base_model.layers[-1].name else base_model.output\n",
    "x = GlobalAveragePooling1D(name=\"new_gap\")(x) if len(x.shape) == 3 else x\n",
    "x = Dropout(0.5, name='new_dropout')(x)\n",
    "output = Dense(7, activation='softmax', name=\"new_prediction\")(x)\n",
    "\n",
    "finetuned_model = Model(inputs=base_model.input, outputs=output)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "16b9405d",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "finetuned_model.compile(\n",
    "    optimizer='adam',\n",
    "    loss='sparse_categorical_crossentropy',\n",
    "    metrics=['accuracy']\n",
    ")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "c63015b6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['y']\n",
      "X_train shape: (24156, 12, 1000), y_train shape: (24156,)\n",
      "X_test shape: (5540, 12, 1000), y_test shape: (5540,)\n",
      "X_train shape: (24156, 12, 1000, 1), y_train shape: (24156,)\n",
      "X_test shape: (5540, 12, 1000, 1), y_test shape: (5540,)\n"
     ]
    }
   ],
   "source": [
    "\n",
    "# # Load preprocessed dataset\n",
    "# train_data = np.load('C:\\\\Users\\\\mstew\\\\OneDrive\\\\Curtin Univeristy\\\\COMP6011\\\\Task 3\\\\ECG-classification-main\\\\train_data.npz')\n",
    "# X_train, y_train = train_data['X'], train_data['y']\n",
    "\n",
    "# test_data = np.load('C:\\\\Users\\\\mstew\\\\OneDrive\\\\Curtin Univeristy\\\\COMP6011\\\\Task 3\\\\ECG-classification-main\\\\test_data.npz')\n",
    "# X_test, y_test = test_data['X'], test_data['y']\n",
    "\n",
    "# Load the balanced dataset\n",
    "X_train = np.load('C:\\\\Users\\\\mstew\\\\OneDrive\\\\Curtin Univeristy\\\\COMP6011\\\\Task 3\\\\ECG-classification-main\\\\X_train_balanced.npz')\n",
    "X_test = np.load('C:\\\\Users\\\\mstew\\\\OneDrive\\\\Curtin Univeristy\\\\COMP6011\\Task 3\\\\ECG-classification-main\\\\X_test_balanced.npz')\n",
    "y_train = np.load('C:\\\\Users\\\\mstew\\\\OneDrive\\\\Curtin Univeristy\\\\COMP6011\\\\Task 3\\\\ECG-classification-main\\\\y_train_balanced.npz') \n",
    "y_test = np.load('C:\\\\Users\\\\mstew\\OneDrive\\\\Curtin Univeristy\\\\COMP6011\\\\Task 3\\\\ECG-classification-main\\\\y_test_balanced.npz')\n",
    "\n",
    "print(y_train.files)\n",
    "# Convert to numpy arrays\n",
    "X_train = X_train['X'] if isinstance(X_train, np.lib.npyio.NpzFile) else X_train\n",
    "X_test = X_test['X'] if isinstance(X_test, np.lib.npyio.NpzFile) else X_test\n",
    "y_train = y_train['y'] if isinstance(y_train, np.lib.npyio.NpzFile) else y_train\n",
    "y_test = y_test['y'] if isinstance(y_test, np.lib.npyio.NpzFile) else y_test\n",
    "\n",
    "\n",
    "# Normalization\n",
    "# X_train = X_train / np.max(np.abs(X_train), axis=(1, 2), keepdims=True)\n",
    "# X_test = X_test / np.max(np.abs(X_test), axis=(1, 2), keepdims=True)\n",
    "\n",
    "print(f\"X_train shape: {X_train.shape}, y_train shape: {y_train.shape}\")\n",
    "print(f\"X_test shape: {X_test.shape}, y_test shape: {y_test.shape}\")\n",
    "\n",
    "# # Reshape to match model input\n",
    "# X_train = np.transpose(X_train, (0, 2, 1))[..., np.newaxis]\n",
    "# X_test = np.transpose(X_test, (0, 2, 1))[..., np.newaxis]\n",
    "\n",
    "# Reshape to match model input\n",
    "# X_test  = X_test.reshape(X_train.shape[0], 12, 1000, 1)\n",
    "# X_train = X_train.reshape(X_train.shape[0], 12, 1000, 1)\n",
    "X_train = X_train[..., np.newaxis]\n",
    "X_test = X_test[..., np.newaxis]\n",
    "\n",
    "\n",
    "print(f\"X_train shape: {X_train.shape}, y_train shape: {y_train.shape}\")\n",
    "print(f\"X_test shape: {X_test.shape}, y_test shape: {y_test.shape}\")\n",
    "\n",
    "# Encode labels to integers\n",
    "from sklearn.preprocessing import LabelEncoder\n",
    "label_encoder = LabelEncoder()\n",
    "y_train = label_encoder.fit_transform(y_train)\n",
    "y_test = label_encoder.transform(y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "2cf5d3c8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Num GPUs Available: 1\n"
     ]
    }
   ],
   "source": [
    "# make sure the GPU is available\n",
    "import tensorflow as tf\n",
    "print(\"Num GPUs Available:\", len(tf.config.list_physical_devices('GPU')))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "a800d158",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Physical devices cannot be modified after being initialized\n"
     ]
    }
   ],
   "source": [
    "gpus = tf.config.list_physical_devices('GPU')\n",
    "if gpus:\n",
    "    try:\n",
    "        # Set memory growth to avoid allocating all GPU memory upfront\n",
    "        for gpu in gpus:\n",
    "            tf.config.experimental.set_memory_growth(gpu, True)\n",
    "        print(\"GPU is set for training.\")\n",
    "    except RuntimeError as e:\n",
    "        print(e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "b9c049c3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['AFLT' 'OTHER' 'RBBB' ... 'AFLT' 'AFLT' 'NORM']\n"
     ]
    }
   ],
   "source": [
    "print(y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "92fe0fc9",
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow.keras.callbacks import ReduceLROnPlateau\n",
    "\n",
    "# Monitor validation loss, reduce LR by a factor of 0.1 if it doesn't improve for 5 epochs\n",
    "lr_reducer = ReduceLROnPlateau(\n",
    "    monitor='val_loss', # or 'val_accuracy'\n",
    "    factor=0.1,         # New_LR = Current_LR * factor\n",
    "    patience=3,         # Number of epochs with no improvement after which learning rate will be reduced.\n",
    "    min_lr=1e-7,        # Lower bound for the learning rate\n",
    "    verbose=1           # Prints a message when LR is reduced\n",
    ")\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "a1cdbb43",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "X_train, X_val, y_train, y_val = train_test_split(\n",
    "    X_train, y_train, stratify=y_train, test_size=0.2, random_state=42\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "1fc0d7c1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/50\n",
      "604/604 [==============================] - 51s 83ms/step - loss: 0.7319 - accuracy: 0.7685 - val_loss: 0.4697 - val_accuracy: 0.8487 - lr: 0.0010\n",
      "Epoch 2/50\n",
      "604/604 [==============================] - 50s 82ms/step - loss: 0.5318 - accuracy: 0.8305 - val_loss: 0.7613 - val_accuracy: 0.7397 - lr: 0.0010\n",
      "Epoch 3/50\n",
      "604/604 [==============================] - 49s 82ms/step - loss: 0.4982 - accuracy: 0.8404 - val_loss: 0.4953 - val_accuracy: 0.8421 - lr: 0.0010\n",
      "Epoch 4/50\n",
      "604/604 [==============================] - ETA: 0s - loss: 0.4650 - accuracy: 0.8549\n",
      "Epoch 4: ReduceLROnPlateau reducing learning rate to 0.00010000000474974513.\n",
      "604/604 [==============================] - 57s 95ms/step - loss: 0.4650 - accuracy: 0.8549 - val_loss: 0.5433 - val_accuracy: 0.8303 - lr: 0.0010\n",
      "Epoch 5/50\n",
      "604/604 [==============================] - 61s 101ms/step - loss: 0.3716 - accuracy: 0.8856 - val_loss: 0.3819 - val_accuracy: 0.8793 - lr: 1.0000e-04\n",
      "Epoch 6/50\n",
      "604/604 [==============================] - 61s 102ms/step - loss: 0.3263 - accuracy: 0.9017 - val_loss: 0.3713 - val_accuracy: 0.8810 - lr: 1.0000e-04\n",
      "Epoch 7/50\n",
      "604/604 [==============================] - 61s 101ms/step - loss: 0.3074 - accuracy: 0.9076 - val_loss: 0.3545 - val_accuracy: 0.8905 - lr: 1.0000e-04\n",
      "Epoch 8/50\n",
      "604/604 [==============================] - 61s 101ms/step - loss: 0.2845 - accuracy: 0.9138 - val_loss: 0.3588 - val_accuracy: 0.8870 - lr: 1.0000e-04\n",
      "Epoch 9/50\n",
      "604/604 [==============================] - 61s 101ms/step - loss: 0.2722 - accuracy: 0.9165 - val_loss: 0.3491 - val_accuracy: 0.8858 - lr: 1.0000e-04\n",
      "Epoch 10/50\n",
      "604/604 [==============================] - 61s 101ms/step - loss: 0.2574 - accuracy: 0.9216 - val_loss: 0.3488 - val_accuracy: 0.8926 - lr: 1.0000e-04\n",
      "Epoch 11/50\n",
      "604/604 [==============================] - 61s 102ms/step - loss: 0.2483 - accuracy: 0.9221 - val_loss: 0.3470 - val_accuracy: 0.8895 - lr: 1.0000e-04\n",
      "Epoch 12/50\n",
      "604/604 [==============================] - 61s 101ms/step - loss: 0.2334 - accuracy: 0.9272 - val_loss: 0.3504 - val_accuracy: 0.8897 - lr: 1.0000e-04\n",
      "Epoch 13/50\n",
      "604/604 [==============================] - 61s 101ms/step - loss: 0.2252 - accuracy: 0.9292 - val_loss: 0.3640 - val_accuracy: 0.8874 - lr: 1.0000e-04\n",
      "Epoch 14/50\n",
      "604/604 [==============================] - ETA: 0s - loss: 0.2153 - accuracy: 0.9332\n",
      "Epoch 14: ReduceLROnPlateau reducing learning rate to 1.0000000474974514e-05.\n",
      "604/604 [==============================] - 61s 100ms/step - loss: 0.2153 - accuracy: 0.9332 - val_loss: 0.3505 - val_accuracy: 0.8913 - lr: 1.0000e-04\n",
      "Epoch 15/50\n",
      "604/604 [==============================] - 61s 101ms/step - loss: 0.1927 - accuracy: 0.9415 - val_loss: 0.3457 - val_accuracy: 0.8947 - lr: 1.0000e-05\n",
      "Epoch 16/50\n",
      "604/604 [==============================] - 60s 100ms/step - loss: 0.1862 - accuracy: 0.9444 - val_loss: 0.3452 - val_accuracy: 0.8961 - lr: 1.0000e-05\n",
      "Epoch 17/50\n",
      "604/604 [==============================] - 61s 101ms/step - loss: 0.1830 - accuracy: 0.9442 - val_loss: 0.3463 - val_accuracy: 0.8971 - lr: 1.0000e-05\n",
      "Epoch 18/50\n",
      "604/604 [==============================] - 60s 100ms/step - loss: 0.1788 - accuracy: 0.9466 - val_loss: 0.3499 - val_accuracy: 0.8967 - lr: 1.0000e-05\n",
      "Epoch 19/50\n",
      "604/604 [==============================] - ETA: 0s - loss: 0.1820 - accuracy: 0.9450\n",
      "Epoch 19: ReduceLROnPlateau reducing learning rate to 1.0000000656873453e-06.\n",
      "604/604 [==============================] - 55s 92ms/step - loss: 0.1820 - accuracy: 0.9450 - val_loss: 0.3497 - val_accuracy: 0.8969 - lr: 1.0000e-05\n",
      "Epoch 20/50\n",
      "604/604 [==============================] - 57s 95ms/step - loss: 0.1782 - accuracy: 0.9463 - val_loss: 0.3517 - val_accuracy: 0.8953 - lr: 1.0000e-06\n",
      "Epoch 21/50\n",
      "604/604 [==============================] - 56s 93ms/step - loss: 0.1794 - accuracy: 0.9463 - val_loss: 0.3506 - val_accuracy: 0.8959 - lr: 1.0000e-06\n",
      "Epoch 22/50\n",
      "604/604 [==============================] - ETA: 0s - loss: 0.1788 - accuracy: 0.9476\n",
      "Epoch 22: ReduceLROnPlateau reducing learning rate to 1.0000001111620805e-07.\n",
      "604/604 [==============================] - 55s 91ms/step - loss: 0.1788 - accuracy: 0.9476 - val_loss: 0.3502 - val_accuracy: 0.8963 - lr: 1.0000e-06\n",
      "Epoch 23/50\n",
      "604/604 [==============================] - 54s 90ms/step - loss: 0.1770 - accuracy: 0.9474 - val_loss: 0.3500 - val_accuracy: 0.8959 - lr: 1.0000e-07\n",
      "Epoch 24/50\n",
      "604/604 [==============================] - 54s 89ms/step - loss: 0.1753 - accuracy: 0.9474 - val_loss: 0.3492 - val_accuracy: 0.8967 - lr: 1.0000e-07\n",
      "Epoch 25/50\n",
      "604/604 [==============================] - ETA: 0s - loss: 0.1792 - accuracy: 0.9460\n",
      "Epoch 25: ReduceLROnPlateau reducing learning rate to 1e-07.\n",
      "604/604 [==============================] - 55s 90ms/step - loss: 0.1792 - accuracy: 0.9460 - val_loss: 0.3509 - val_accuracy: 0.8957 - lr: 1.0000e-07\n",
      "Epoch 26/50\n",
      "604/604 [==============================] - ETA: 0s - loss: 0.1774 - accuracy: 0.9473Restoring model weights from the end of the best epoch: 16.\n",
      "604/604 [==============================] - 55s 91ms/step - loss: 0.1774 - accuracy: 0.9473 - val_loss: 0.3512 - val_accuracy: 0.8955 - lr: 1.0000e-07\n",
      "Epoch 26: early stopping\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "from tensorflow.keras.callbacks import EarlyStopping\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "finetuned_model.compile(\n",
    "    optimizer='adam',\n",
    "    loss='sparse_categorical_crossentropy',\n",
    "    metrics=['accuracy']\n",
    ")\n",
    "\n",
    "# Early stopping to prevent overfitting\n",
    "early_stop = EarlyStopping(\n",
    "    monitor='val_loss',\n",
    "    patience=10,\n",
    "    restore_best_weights=True,\n",
    "    verbose=1\n",
    ")\n",
    "\n",
    "# Train the model\n",
    "history = finetuned_model.fit(\n",
    "    X_train, y_train,\n",
    "    validation_data=(X_val, y_val),\n",
    "    epochs=50,\n",
    "    batch_size=32,\n",
    "    callbacks=[early_stop, lr_reducer]\n",
    ")\n",
    "\n",
    "# Plot training & validation accuracy/loss\n",
    "plt.figure(figsize=(12, 5))\n",
    "\n",
    "# Accuracy\n",
    "plt.subplot(1, 2, 1)\n",
    "plt.plot(history.history['accuracy'], label='Train Accuracy')\n",
    "plt.plot(history.history['val_accuracy'], label='Validation Accuracy')\n",
    "plt.title('Model Accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "plt.ylabel('Accuracy')\n",
    "plt.legend()\n",
    "\n",
    "# Loss\n",
    "plt.subplot(1, 2, 2)\n",
    "plt.plot(history.history['loss'], label='Train Loss')\n",
    "plt.plot(history.history['val_loss'], label='Validation Loss')\n",
    "plt.title('Model Loss')\n",
    "plt.xlabel('Epoch')\n",
    "plt.ylabel('Loss')\n",
    "plt.legend()\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "ea780290",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "finetuned_model.save('finetuned_ecg_model2.h5')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4eb3bd9a",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"###Import Libraries\"\"\"\n",
    "from tensorflow.keras.layers import (Conv2D, Add,Activation,\n",
    "                                     Dropout,Dense,Flatten,Input,BatchNormalization,\n",
    "                                      ReLU,MaxPooling2D,Concatenate,GlobalAveragePooling2D\n",
    "                                     )\n",
    "from tensorflow.keras.models import Sequential\n",
    "from tensorflow.keras import optimizers, losses, metrics, regularizers, callbacks\n",
    "from tensorflow.keras.models import Model\n",
    "import tensorflow as tf\n",
    "import numpy as np\n",
    "import os"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cff82f98",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"#### Import Data\"\"\"\n",
    "\n",
    "path = 'data path'\n",
    "\n",
    "calssificatin_type = {\"binary\":1,\"superclasses\":5,\"subclasses\":23}\n",
    "classification_name=\"subclasses\"\n",
    "no_of_classes=calssificatin_type[classification_name]\n",
    "\n",
    "lead_type={\"lead-I\":1, \"bipolar-limb\":3 , \"unipolar-limb\":3, \"limb-leads\":6 , \"precordial-leads\":6,\"all-lead\":12}\n",
    "lead_name= \"all-lead\"\n",
    "no_of_leads=lead_type[lead_name]\n",
    "\n",
    "x_train = np.load(path + 'x_train.npy',allow_pickle=True)\n",
    "x_test  = np.load(path + 'x_test.npy',allow_pickle=True)\n",
    "y_train = np.load(path + 'y_train.npy',allow_pickle=True)\n",
    "y_test  = np.load(path + 'y_test.npy',allow_pickle=True)\n",
    "\n",
    "# print(x_train.shape)\n",
    "# print(x_test.shape)\n",
    "\n",
    "x_train = x_train.transpose(0, 2, 1)            # transpose working correctly\n",
    "x_test  = x_test.transpose(0, 2, 1)\n",
    "\n",
    "# print(x_train.shape)\n",
    "# print(x_test.shape)\n",
    "\n",
    "x_train = x_train.reshape(19601, no_of_leads, 1000, 1)   # Add another channel\n",
    "x_test  = x_test.reshape(2198, no_of_leads, 1000, 1)\n",
    "\n",
    "\n",
    "print(\"x_train :\", x_train.shape)\n",
    "print(\"y_train :\", y_train.shape)\n",
    "print(\"x_test  :\", x_test.shape)\n",
    "print(\"y_test  :\", y_test.shape)\n",
    "print('Data loaded')\n",
    "\n",
    "\n",
    "from sklearn.preprocessing import MultiLabelBinarizer\n",
    "\n",
    "if classification_name!=\"binary\":\n",
    "    mlb = MultiLabelBinarizer()\n",
    "    mlb.fit(y_train)\n",
    "    y_train = mlb.transform(y_train)\n",
    "\n",
    "    mlb = MultiLabelBinarizer()\n",
    "    mlb.fit(y_test)\n",
    "    y_test = mlb.transform(y_test)\n",
    "    print('Data proocessed')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1e01b034",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"#### Model\"\"\"\n",
    "\n",
    "input= Input(shape=(no_of_leads, 1000, 1))\n",
    "\n",
    "\n",
    "conv1 = Conv2D(filters=32, kernel_size=(1,7),strides=(1, 1))(input)\n",
    "batch1 = BatchNormalization()(conv1)\n",
    "relu1 = ReLU()(batch1)\n",
    "\n",
    "conv2 = Conv2D(filters=64, kernel_size=(1,5),strides=(1, 1))(relu1)\n",
    "batch2 = BatchNormalization()(conv2)\n",
    "relu2 = ReLU()(batch2)\n",
    "drop2 = Dropout(rate=0.1)(relu2)\n",
    "conv2 = Conv2D(filters=64, kernel_size=(1,5),strides=(1, 2))(drop2)\n",
    "\n",
    "max1 = MaxPooling2D(pool_size=(1,9),strides=(1,2))(relu1)\n",
    "conv_ = Conv2D(64, (1, 1))(max1)\n",
    "conc1 = Add()([conv2, conv_])\n",
    "\n",
    "batch3 = BatchNormalization()(conc1)\n",
    "relu3 = ReLU()(batch3)\n",
    "drop3 = Dropout(rate=0.1)(relu3)\n",
    "conv3 = Conv2D(filters=64, kernel_size=(1,5),strides=(1, 1))(drop3)\n",
    "batch3 = BatchNormalization()(conv3)\n",
    "relu3 = ReLU()(batch3)\n",
    "drop3 = Dropout(rate=0.1)(relu3)\n",
    "conv3 = Conv2D(filters=64, kernel_size=(1,5),strides=(1, 2))(drop3)\n",
    "\n",
    "\n",
    "max2 = MaxPooling2D(pool_size=(1,9),strides=(1,2))(conc1)\n",
    "conc2 = Add()([conv3, max2])\n",
    "\n",
    "batch3 = BatchNormalization()(conc2)\n",
    "relu3 = ReLU()(batch3)\n",
    "drop3 = Dropout(rate=0.1)(relu3)\n",
    "conv3 = Conv2D(filters=128, kernel_size=(1,5),strides=(1, 1))(drop3)\n",
    "batch3 = BatchNormalization()(conv3)\n",
    "relu3 = ReLU()(batch3)\n",
    "drop3 = Dropout(rate=0.1)(relu3)\n",
    "conv3 = Conv2D(filters=128, kernel_size=(1,5),strides=(1, 2))(drop3)\n",
    "\n",
    "\n",
    "max3 = MaxPooling2D(pool_size=(1,9),strides=(1,2))(conc2)\n",
    "conv_ = Conv2D(128, (1, 1))(max3)\n",
    "conc3 = Add()([conv3, conv_])\n",
    "\n",
    "batch3 = BatchNormalization()(conc3)\n",
    "relu3 = ReLU()(batch3)\n",
    "drop3 = Dropout(rate=0.1)(relu3)\n",
    "conv3 = Conv2D(filters=128, kernel_size=(1,5),strides=(1, 1))(drop3)\n",
    "batch3 = BatchNormalization()(conv3)\n",
    "relu3 = ReLU()(batch3)\n",
    "drop3 = Dropout(rate=0.1)(relu3)\n",
    "conv3 = Conv2D(filters=128, kernel_size=(1,5),strides=(1, 2))(drop3)\n",
    "\n",
    "\n",
    "max4 = MaxPooling2D(pool_size=(1,9),strides=(1,2))(conc3)\n",
    "conc4 = Add()([conv3, max4])\n",
    "          \n",
    "\n",
    "conv3 = Conv2D(filters=128, kernel_size=(no_of_leads, 1))(conc4)\n",
    "X = BatchNormalization()(conv3)\n",
    "X = ReLU()(X)\n",
    "X = GlobalAveragePooling2D()(X)\n",
    "\n",
    "X = Flatten()(X)\n",
    "print(X.shape)\n",
    "\n",
    "X = Dense(units=128, kernel_regularizer=tf.keras.regularizers.L2(0.005))(X)\n",
    "X = BatchNormalization()(X)\n",
    "X = ReLU()(X)\n",
    "X = Dropout(rate=0.1)(X)\n",
    "\n",
    "X = Dense(units=64, kernel_regularizer=tf.keras.regularizers.L2(0.009))(X)\n",
    "X = BatchNormalization()(X)\n",
    "X = ReLU()(X)\n",
    "X = Dropout(rate=0.15)(X)\n",
    "print('Added 2 fully connected layers')\n",
    "\n",
    "output = Dense(no_of_classes, activation='sigmoid')(X)\n",
    "model = Model(inputs=input, outputs=output)\n",
    "\n",
    "print(model.summary())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bc725d65",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"#### Train Model\"\"\"\n",
    "import tensorflow as tf \n",
    "early    = callbacks.EarlyStopping(monitor=\"val_loss\", patience=6, restore_best_weights=True)\n",
    "reducelr = callbacks.ReduceLROnPlateau(monitor=\"val_loss\", patience=3)\n",
    "\n",
    "callback = [early, reducelr]\n",
    "\n",
    "\n",
    "model.compile(optimizer = optimizers.Adam(learning_rate=0.0005),\n",
    "              loss = losses.BinaryCrossentropy(),\n",
    "              metrics = [metrics.BinaryAccuracy(), metrics.AUC(curve='ROC', multi_label=True)])\n",
    "\n",
    "history = model.fit(x_train, y_train, validation_split=0.12, epochs=100, batch_size=32, callbacks=callback)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d053893f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# \"\"\"##### Save Model\"\"\"\n",
    "\n",
    "save_path = 'save_path/'\n",
    "model.save(save_path + \"First_Paper.h5\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0b46abd3",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"Evaluate the model\"\"\"\n",
    "\n",
    "from sklearn.metrics import precision_recall_curve, f1_score, roc_auc_score, accuracy_score, auc\n",
    "\n",
    "\n",
    "def sklearn_metrics(y_true, y_pred):\n",
    "    y_bin = np.copy(y_pred)\n",
    "    y_bin[y_bin >= 0.5] = 1\n",
    "    y_bin[y_bin < 0.5]  = 0\n",
    "\n",
    "    # Compute area under precision-Recall curve\n",
    "    auc_sum = 0\n",
    "    for i in range(no_of_classes):\n",
    "      precision, recall, thresholds = precision_recall_curve(y_true[:, i], y_pred[:,i])\n",
    "      auc_sum += auc(recall, precision)\n",
    "\n",
    "    print(\"Accuracy        : {:.2f}\".format(accuracy_score(y_true.flatten(), y_bin.flatten())* 100))\n",
    "    print(\"Macro AUC score : {:.2f}\".format(roc_auc_score(y_true, y_pred, average='macro') * 100))\n",
    "    print('AUPRC           : {:.2f}'.format((auc_sum / no_of_classes) * 100))\n",
    "    print(\"Micro F1 score  : {:.2f}\".format(f1_score(y_true, y_bin, average='micro') * 100))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b8e1b2cf",
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import Tuple\n",
    "import numpy as np\n",
    "import os\n",
    "\n",
    "import numpy as np\n",
    "import warnings\n",
    "from sklearn.metrics import roc_auc_score, accuracy_score\n",
    "\n",
    "\n",
    "def Metrics(y_true: np.ndarray, y_scores: np.ndarray) -> Tuple[float, float]:\n",
    "    \"\"\"Metrics for class-wise accuracy and mean accuracy.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    y_true : np.ndarray\n",
    "        Ground truth labels.\n",
    "    y_scores : np.ndarray\n",
    "        Predicted labels.\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    tuple[np.ndarray]\n",
    "        Tuple of arrays containing class-wise accuracy and mean accuracy.\n",
    "\n",
    "    \"\"\"\n",
    "\n",
    "    y_pred = y_scores >= 0.5\n",
    "    acc = np.zeros(y_pred.shape[-1])\n",
    "\n",
    "    for i in range(y_pred.shape[-1]):\n",
    "        acc[i] = accuracy_score(y_true[:, i], y_pred[:, i])\n",
    "\n",
    "    return acc.tolist(), np.mean(acc)\n",
    "\n",
    "\n",
    "def AUC(y_true: np.ndarray, y_pred: np.ndarray, verbose: bool = False) -> float:\n",
    "    \"\"\"Computes the macro-averaged AUC score.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    y_true : np.ndarray\n",
    "        Ground truth labels.\n",
    "    y_scores : np.ndarray\n",
    "        Predicted probabilities.\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    float\n",
    "        macro-average AUC score.\n",
    "\n",
    "    \"\"\"\n",
    "\n",
    "    aucs = []\n",
    "    assert (\n",
    "        len(y_true.shape) == 2 and len(y_pred.shape) == 2\n",
    "    ), \"Predictions and labels must be 2D.\"\n",
    "    for col in range(y_true.shape[1]):\n",
    "        try:\n",
    "            aucs.append(roc_auc_score(y_true[:, col], y_pred[:, col]))\n",
    "        except ValueError as e:\n",
    "            if verbose:\n",
    "                print(\n",
    "                    f\"Value error encountered for label {col}, likely due to using mixup or \"\n",
    "                    f\"lack of full label presence. Setting AUC to accuracy. \"\n",
    "                    f\"Original error was: {str(e)}.\"\n",
    "                )\n",
    "            aucs.append((y_pred == y_true).sum() / len(y_pred))\n",
    "    return aucs\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9cb44cf1",
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred_train = model.predict(x_train)\n",
    "y_pred_test  = model.predict(x_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "31513190",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Train\")\n",
    "sklearn_metrics(y_train, y_pred_train)\n",
    "print(\"\\nTest\")\n",
    "sklearn_metrics(y_test, y_pred_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0a7309d7",
   "metadata": {},
   "outputs": [],
   "source": [
    "acc, mean_acc = Metrics(y_test, y_pred_test)\n",
    "class_auc = AUC(y_test, y_pred_test)\n",
    "\n",
    "print(f\"class wise accuracy: {acc}\")\n",
    "\n",
    "print(f\"class wise AUC : {class_auc}\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "ECG_39",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.21"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
